﻿#define _CRT_SECURE_NO_WARNINGS 
//给你一个整数数组 arr，请你帮忙统计数组中每个数的出现次数。
//
//如果每个数的出现次数都是独一无二的，就返回 true；否则返回 false。
//bool uniqueOccurrences(int* arr, int arrSize){
//	char a1[2001] = { 0 };
//	char a2[2001] = { 0 };
//	int i = 0;
//	for (i = 0; i<arrSize; i++)
//	{
//		a1[arr[i] + 1000]++;
//	}
//	for (i = 0; i<2001; i++)
//	{
//		if (a1[i]>0 && a2[a1[i]]>0)
//		{
//			return false;
//		}
//		else
//		{
//			a2[a1[i]] = 1;
//		}
//	}
//	return true;
//}








//编写一个函数，输入是一个无符号整数（以二进制串的形式），返回其二进制表达式中数字位数为 '1' 的个数（也被称为汉明重量）。    
//int hammingWeight(uint32_t n) {
//	int count = 0;
//	while (n>0)
//	{
//		if (n & 1 != 0)
//		{
//			count++;
//		}
//		n /= 2;
//	}
//	return count;
//}






/**自除数 是指可以被它包含的每一位数除尽的数。
例如，128 是一个自除数，因为 128 % 1 == 0，128 % 2 == 0，128 % 8 == 0。
还有，自除数不允许包含 0 。
给定上边界和下边界数字，输出一个列表，列表的元素是边界（含边界）内所有的自除
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/self-dividing-numbers
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
* Note: The returned array must be malloced, assume caller calls free().
*/
//int* selfDividingNumbers(int left, int right, int* returnSize){
//	int* a = (int*)malloc(sizeof(int)*right);
//	int tmp = 0;
//	int x = 0;
//	int i = 0;
//	while (left <= right)
//	{
//		tmp = left;
//		while (tmp != 0)
//		{
//			x = tmp % 10;
//			if (x == 0)
//			{
//				break;
//			}
//			if (left%x != 0)
//			{
//				break;
//			}
//			tmp /= 10;
//		}
//		if (tmp == 0)
//		{
//			a[i] = left;
//			i++;
//			left++;
//		}
//		else
//		{
//			left++;
//		}
//	}
//	*returnSize = i;
//	return a;
//}







//请实现一个函数，把字符串 s 中的每个空格替换成"%20"
//char* replaceSpace(char* s){
//	int len = strlen(s);
//	char* a = (char*)malloc(sizeof(char)*len * 3 + 1);
//	char* p = a;
//	char* q = s;
//	while (*q != '\0')
//	{
//		if (*q != ' ')
//		{
//			*p = *q;
//			p++;
//		}
//		else
//		{
//			*p = '%';
//			p++;
//			*p = '2';
//			p++;
//			*p = '0';
//			p++;
//		}
//		q++;
//	}
//	*p = '\0';
//	return a;
//}










//给你一个整数数组 nums，请你选择数组的两个不同下标 i 和 j，使(nums[i] - 1)*(nums[j] - 1) 取得最大值。
//请你计算并返回该式的最大值。
//int maxProduct(int* nums, int numsSize){
//	int count = 0;
//	int i = 0;
//	int j = 0;
//	int tmp = 0;
//	for (i = 0; i<numsSize; i++)
//	{
//		for (j = 0; j<numsSize - 1; j++)
//		{
//			if (nums[j]>nums[j + 1])
//			{
//				tmp = nums[j];
//				nums[j] = nums[j + 1];
//				nums[j + 1] = tmp;
//			}
//		}
//	}
//	int x = nums[numsSize - 2];
//	int y = nums[numsSize - 1];
//	int n = (x - 1)*(y - 1);
//	return n;
//}







//在二维平面上，有一个机器人从原点(0, 0) 开始。给出它的移动顺序，判断这个机器人在完成移动后是否在 (0, 0) 处结束。
//移动顺序由字符串表示。字符 move[i] 表示其第 i 次移动。机器人的有效动作有 R（右），L（左），U（上）和 D（下）。如果机器人在完成所有动作后返回原点，则返回 true。否则，返回 false。
//注意：机器人“面朝”的方向无关紧要。 “R” 将始终使机器人向右移动一次，“L” 将始终向左移动等。此外，假设每次移动机器人的移动幅度相同。
//来源：力扣（LeetCode）
//链接：https ://leetcode-cn.com/problems/robot-return-to-origin
//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
//bool judgeCircle(char * moves){
//	int count = 0;
//	int len = strlen(moves);
//	int i = 0;
//	for (i = 0; i<len; i++)
//	{
//		if (moves[i] == 'R')
//		{
//			count += 100;
//		}
//		else if (moves[i] == 'L')
//		{
//			count -= 100;
//		}
//		else if (moves[i] == 'U')
//		{
//			count++;
//		}
//		else
//		{
//			count--;
//		}
//	}
//	if (count == 0)
//	{
//		return true;
//	}
//	else
//	{
//		return false;
//	}
//}








//给你一份旅游线路图，该线路图中的旅行线路用数组 paths 表示，其中 paths[i] = [cityAi, cityBi] 表示该线路将会从 cityAi 直接前往 cityBi 。请你找出这次旅行的终点站，即没有任何可以通往其他城市的线路的城市。
//题目数据保证线路图会形成一条不存在循环的线路，因此只会有一个旅行终点站。
//来源：力扣（LeetCode）
//链接：https ://leetcode-cn.com/problems/destination-city
//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
//char * destCity(char *** paths, int pathsSize, int* pathsColSize){
//	int col = *pathsColSize;
//	char* p = paths[0][col - 1];
//	int i = 0;
//	for (i = 1; i<pathsSize; i++)
//	{
//		if (strcmp(paths[i][0], p) == 0)
//		{
//			p = paths[i][col - 1];
//			i = 0;
//		}
//	}
//	return p;
//}
//
//
//
//
//
//
//
//1输入数字 n，按顺序打印出从 1 到最大的 n 位十进制数。比如输入 3，则打印出 1、2、3 一直到最大的 3 位数 999。
///**
//* Note: The returned array must be malloced, assume caller calls free().
//*/
//int* printNumbers(int n, int* returnSize){
//	int i = 0;
//	int len = 1;
//	for (i = 0; i<n; i++)
//	{
//		len *= 10;
//	}
//	int* a = (int*)malloc(len*sizeof(int));
//	for (i = 0; i<len - 1; i++)
//	{
//		a[i] = i + 1;
//	}
//	*returnSize = len - 1;
//	return a;
//}
//
//
//
//
//
//
//
//
//字母的 字母值 取决于字母在字母表中的位置，从 0 开始 计数。即，'a' -> 0、'b' -> 1、'c' -> 2，以此类推。
//对某个由小写字母组成的字符串 s 而言，其 数值 就等于将 s 中每个字母的 字母值 按顺序 连接 并 转换 成对应整数。
//例如，s = "acb" ，依次连接每个字母的字母值可以得到 "021" ，转换为整数得到 21 。
//给你三个字符串 firstWord、secondWord 和 targetWord ，每个字符串都由从 'a' 到 'j' （含 'a' 和 'j' ）的小写英文字母组成。
//如果 firstWord 和 secondWord 的 数值之和 等于 targetWord 的数值，返回 true ；否则，返回 false 。
//int str(char* p)
//{
//	int arr = 0;
//	int len = strlen(p);
//	int i = 0;
//	for (i = 0; i<len; i++)
//	{
//		arr = arr * 10 + (p[i] - 'a');
//	}
//	return arr;
//}
//bool isSumEqual(char * firstWord, char * secondWord, char * targetWord){
//	return str(firstWord) + str(secondWord) == str(targetWord);
//}
//
//
//
//
//
//
//
//
//给你两个字符串 word1 和 word2 。请你从 word1 开始，
//通过交替添加字母来合并字符串。如果一个字符串比另一个字符串长，
//就将多出来的字母追加到合并后字符串的末尾。
//返回 合并后的字符串 。
//来源：力扣（LeetCode）
//链接：https ://leetcode-cn.com/problems/merge-strings-alternately
//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
//#include <stdio.h>
//char * mergeAlternately(char * word1, char * word2){
//	int len = strlen(word1);
//	int len1 = strlen(word2);
//	char* a = (char*)malloc((len + len1 + 1)*sizeof(char));
//	int i = 0;
//	int j = 0;
//	while (i<len&&i<len1)
//	{
//		a[j++] = word1[i];
//		a[j++] = word2[i];
//		i++;
//	}
//	if (i == len)
//	{
//		while (i<len1)
//		{
//			a[j++] = word2[i];
//			i++;
//		}
//	}
//	else
//	{
//		while (i<len)
//		{
//			a[j++] = word1[i];
//			i++;
//		}
//	}
//	a[j++] = '\0';
//	return a;
//}